/**
 * 
 */
package com.yidu.drug.action;

import java.math.BigDecimal;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.UUID;

import javax.annotation.Resource;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.yidu.drug.common.Page;
import com.yidu.drug.common.Tools;
import com.yidu.drug.model.DrugManagerModel;
import com.yidu.drug.model.FdPoBreakdownModel;
import com.yidu.drug.model.FdPurchaseModel;
import com.yidu.drug.model.FdSellDetailModel;
import com.yidu.drug.model.FinancialRecordModel;
import com.yidu.drug.model.FinancialSheetsModel;
import com.yidu.drug.model.InventoryModel;
import com.yidu.drug.model.InventoryRecordModel;
import com.yidu.drug.model.RepertoryModel;
import com.yidu.drug.model.ReturnsDetailModel;
import com.yidu.drug.model.SalesReturnModel;
import com.yidu.drug.model.WholesaleDetailModel;
import com.yidu.drug.model.WholesaleModel;
import com.yidu.drug.service.FdPoBreakdownModelService;
import com.yidu.drug.service.FdPurchaseService;
import com.yidu.drug.service.FdSellDetailService;
import com.yidu.drug.service.FinancialRecordService;
import com.yidu.drug.service.FinancialSheetsService;
import com.yidu.drug.service.InventoryRecordService;
import com.yidu.drug.service.InventoryService;
import com.yidu.drug.service.RepertoryService;
import com.yidu.drug.service.ReturnsDetailService;
import com.yidu.drug.service.SalesReturnService;
import com.yidu.drug.service.WholesaleDetaiService;
import com.yidu.drug.service.WholesaleService;

/**
 * 类的描述--退货单明细表action
 * @author meilina
 * @date 2018年8月9日下午3:22:40
 * @version 1.0
 */
@Controller
@RequestMapping("/detail")
public class ReturnsDetailAction {
	/**
	 * 分店销售详情Service
	 */
	@Resource
	private FdSellDetailService fdSellDetailService;
	
	/**
	 * 采购明细Service
	 */
	@Resource
	private FdPoBreakdownModelService  fdPoBreakdownModelService;
	
	/**
	 * 采购Service
	 */
	@Resource
	private FdPurchaseService  fdPurchaseService;
	/**
	 * 批发Service
	 */
	@Resource
	private WholesaleService wholesaleService;
	/**
	 * 批发详情Service
	 */
	@Resource
	private WholesaleDetaiService wholesaleDetaiService;
	/**
	 * 退货Service
	 */
	@Resource
	private SalesReturnService salesReturnService;
	/**
	 * 退货详情Service
	 */
	@Resource
	private ReturnsDetailService returnsDetailService;
	/**
	 * 财务Service
	 */
	@Resource
	private FinancialSheetsService financialSheetsService;
	/**
	 * 财务记录Service
	 */
	@Resource
	private FinancialRecordService financialRecordService;
	/**
	 * 库存Service
	 */
	@Resource
	private RepertoryService repertoryService;
	/**
	 * 库存记录Service
	 */
	@Resource
	private InventoryRecordService inventoryRecordService;
	
	/**
	 * 库存明细Service
	 */
	@Resource
	private InventoryService inventoryService;
	
	
	/**
	 * 审核不通过后的修改(批发退货) --meilina
	 * @param response 响应
	 * @param pfId 传入的参数批发ID
	 * @return 自定义参数
	 */
	@RequestMapping("/updateIsvas")
	@ResponseBody
	public String updateIsvas(HttpServletResponse response,String pfId){
		//定义行数  =  调用批发Service的修改通过批发ID方法
		int rows =  wholesaleService.updateByPfId(pfId);
		//如果行数大于0
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//否则返回失败
			return "no";
		}	
		
	}
	/**
	 * 审核不通过后的修改(采购退货) -- meilina
	 * @param response 响应
	 * @param fdPoId 采购ID
	 * @return 自定义参数
	 */
	@RequestMapping("/updateFdPoState")
	@ResponseBody
	public String updateFdPoState(HttpServletResponse response,String fdPoId){
		//定义行数  =  调用采购Service的修改通过采购ID方法
		int rows =  fdPurchaseService.updateByFdPoId(fdPoId);
		//如果行数大于0
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//返回失败
			return "no";
		}	
		
	}
	
	
	/**
	 * 查询所有和条件查询分页 -- meilina
	 * @param response 响应
	 * @param me 会员对象
	 * @param page 页数
	 * @param limit 行数
	 * @return maps 集合
	 */
	@RequestMapping("detailFindAll")
	@ResponseBody
	public Map<String, Object> findAll(HttpServletResponse response,ReturnsDetailModel me,int page,int limit) {
		//响应设置编码
		response.setCharacterEncoding("UTF-8");
		//新建页面对象
		Page pages = new Page();
		//设置页数
		pages.setPage(page);
		//设置行数
		pages.setRows(limit);
		//新建Map集合
		Map<String,String> map=new HashMap<>();
		//根据条件查询的搜索框--药品ID
		map.put("drugId", me.getDrugId());
		//根据条件查询的搜索框--操作人
		map.put("oper", me.getOper());
		//开始行数   String强转
		map.put("start", String.valueOf(pages.getStart()));
		//总行数   String强转
		map.put("rows", String.valueOf(pages.getRows()));
		//退货详情集合 = 调用退货详情Service的查找所有页数方法
		List<ReturnsDetailModel> list = returnsDetailService.findAllPage(map);
		//新建Map集合
		Map<String, Object> maps = new HashMap<>();
		//需要符合layUI格式，code msg count调用退货详情Service的查找总行数方法 data
		maps.put("code", 0);
		maps.put("msg", "1");
		maps.put("count", returnsDetailService.findTotalRows(me));
		maps.put("data", list);
		//新建退货详情模型
		me=new ReturnsDetailModel();
		//返回maps集合
		return maps;
	}
	
	/**
	 * 修改
	 * @param id 
	 * @return 页面跳转
	 */
	@RequestMapping("deleteDetail")
	@ResponseBody
	public String deleteMember(String id){
		String str=null;
		if(!Tools.isEmpty(id)){
			int row= returnsDetailService.deleteByPrimaryKey(id);
			if(row>0){
				str="ok";
			}
		}
		return str;

	}
	/**
	 * 增加和修改
	 * @param session web存储空间
	 * @param me 会员对象
	 * @return 页面跳转
	 */
	@RequestMapping("/addOrUpdate")
	public String addOrUpdate(HttpSession session, ReturnsDetailModel me) {
		
		
		Timestamp reDate = new Timestamp(new Date().getTime());
		if(!Tools.isEmpty(me.getRdId())) {
			
			me.setRdId(UUID.randomUUID().toString());
			me.setOptime(reDate);
			returnsDetailService.insert(me);
		}else {
			returnsDetailService.updateByPrimaryKeySelective(me);
		}
		
		
		return "redirect:/pages/yq/returnsDetail.html";
	}
	
	
	
	
	/**
	 * 判断退货数量与总数量(零售) --meilina
	 * @param response 响应
	 * @param jsonStr 传过来的json参数
	 * @param totalMoney 总金额
	 * @param reCause 退货原因
	 * @param returnDetail 退货详情参数
	 * @return 字符串
	 */
	@RequestMapping("/xgSl")
	@ResponseBody
	public String xgSl(HttpServletResponse response,String jsonStr,BigDecimal totalMoney,String reCause,ReturnsDetailModel returnDetail,HttpSession session){
		
		//新建一个Gson对象
		Gson gson = new Gson();		
		//java.lang.reflect.Type,TypeToken内的泛型就是Json数据中的类型(分店销售详情模型)
		java.lang.reflect.Type listType=new TypeToken<ArrayList<FdSellDetailModel>>(){}.getType();
		//集合(分店销售详情模型) gson 上面定义的参数
		ArrayList<FdSellDetailModel> list = gson.fromJson(jsonStr, listType);
		//定义参数rows初始化
		int rows = 0;
		//foreach循环分店销售详情表
		for(FdSellDetailModel  fdSellDetailModel :list){
			//如果分店销售详情的已退货数量为空
			if(fdSellDetailModel.getYthNumber()==null){
				//将分店销售详情表中的已退货数量赋值零
				fdSellDetailModel.setYthNumber(0);
			}
				//定义一个long型参数=分店销售详情表的数量Q-(分店销售详情表的退货数量+分店销售详情表的已退货数量)
				long one = fdSellDetailModel.getMxQuantity()-(fdSellDetailModel.getRdNumber()+fdSellDetailModel.getYthNumber());
				//给分店销售详情表的数量赋值(上面long型参数名)
				fdSellDetailModel.setMxQuantity(one);
				//给分店销售详情表的已退货数量赋值(分店销售详情表的退货数量)
			
				fdSellDetailModel.setYthNumber(fdSellDetailModel.getRdNumber());
				//rows = 调用分店销售详情的修改方法
				rows =fdSellDetailService.updateByPrimaryKeySelective(fdSellDetailModel);
				//调用save方法(退货详情，总金额，退货原因，jsonStr格式)
				save(returnDetail, totalMoney, reCause, jsonStr,session);
			
		}
		//如果rows大于零
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//否则返回失败
			return "no";
		}	
		
	}
	
	
	/**
	 * 判断退货数量与总数量(批发)--meilina
	 * @param response  响应
	 * @param jsonStr 传过来的json参数
	 * @param totalMoney  总金额
	 * @param reCause 原因
	 * @param returnDetail 退货详情参数 
	 * @return 字符串
	 */
	@RequestMapping("/xgSlPf")
	@ResponseBody
	public String xgSlPf(HttpServletResponse response,String jsonStr,BigDecimal totalMoney,String reCause,ReturnsDetailModel returnDetail){
		
		//新建一个Gson对象
		Gson gson = new Gson();
		//java.lang.reflect.Type,TypeToken内的泛型就是Json数据中的类型（批发详情模型）
		java.lang.reflect.Type listType=new TypeToken<ArrayList<WholesaleDetailModel>>(){}.getType();
		//集合(批发详情模型) gson 上面定义的参数
		ArrayList<WholesaleDetailModel> list = gson.fromJson(jsonStr, listType);
		//定义参数rows初始化
		int rows = 0;
		//foreach循环批发详情表
		for(WholesaleDetailModel  wholesaleDetailModel :list){
			//如果批发详情的已退货数量为空
			if(wholesaleDetailModel.getYthNumber()==null){
				//将批发详情中的已退货数量赋值零
				wholesaleDetailModel.setYthNumber(0);
			}
			    //定义一个Integer型参数=批发详情的数量-(批发详情的退货数量+批发详情的已退货数量)
				Integer one = wholesaleDetailModel.getPfxqNumber()-(wholesaleDetailModel.getRdNumber()+wholesaleDetailModel.getYthNumber());
				//给批发详情的数量赋值(上面Integer型参数名)
				wholesaleDetailModel.setPfxqNumber(one);
				//给批发详情的已退货数量赋值(批发详情的退货数量)
				wholesaleDetailModel.setYthNumber(wholesaleDetailModel.getRdNumber());
				//rows = 调用批发详情的修改方法
				rows =wholesaleDetaiService.updateByPrimaryKeySelective(wholesaleDetailModel);
				//调用saves方法(退货详情，总金额，退货原因，jsonStr格式)
				saves(returnDetail, totalMoney,reCause, jsonStr);
				
		}
		//如果rows大于零
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//否则返回失败
			return "no";
		}	
		
	}
	
	
	/**
	 * 判断退货数量与总数量(采购)--meilina
	 * @param response  响应
	 * @param jsonStr 传过来的json参数
	 * @param totalMoney  总金额
	 * @param reCause 原因
	 * @param returnDetail 退货详情参数 
	 * @return 字符串
	 */
	@RequestMapping("/xgSlCg")
	@ResponseBody
	public String xgSlCg(HttpServletResponse response,String jsonStr,BigDecimal totalMoney,String reCause,ReturnsDetailModel returnDetail){
	
		//新建一个Gson对象
		Gson gson = new Gson();
		//java.lang.reflect.Type,TypeToken内的泛型就是Json数据中的类型（采购详情模型）
		java.lang.reflect.Type listType=new TypeToken<ArrayList<FdPoBreakdownModel>>(){}.getType();
		//集合(采购详情模型) gson 上面定义的参数
		ArrayList<FdPoBreakdownModel> list = gson.fromJson(jsonStr, listType);
		//定义参数rows初始化
		int rows = 0;
		//foreach循环分店采购明细表
		for(FdPoBreakdownModel  fdPoBreakdownModel :list){
			//如果分店采购明细的已退货数量为空
			if(fdPoBreakdownModel.getYthNumber()==null){
				//将分店采购明细的已退货数量赋值零
				fdPoBreakdownModel.setYthNumber(0);
			}
			    //定义一个long型参数=采购明细的数量-(采购明细的退货数量+采购明细的已退货数量)
				long one = fdPoBreakdownModel.getFdItemNumber()-(fdPoBreakdownModel.getRdNumber()+fdPoBreakdownModel.getYthNumber());
				//给采购明细的数量赋值(上面long型参数名)
				fdPoBreakdownModel.setFdItemNumber((one));
				//给采购明细的已退货数量赋值(采购明细的退货数量)
				fdPoBreakdownModel.setYthNumber(fdPoBreakdownModel.getRdNumber());
				//rows = 调用采购明细的修改方法
				rows =fdPoBreakdownModelService.updateByPrimaryKeySelective(fdPoBreakdownModel);
				//调用savess方法(退货详情，总金额，退货原因，jsonStr格式)
				savess(returnDetail, totalMoney,reCause, jsonStr);
				
			
		}
		//如果rows大于零
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//否则返回失败
			return "no";
		}	
		
	}
	
	
	
	
	/** 
	 * 财务减少 库存增加的方法(零售退货)    梅李娜
	 * @param returnDetail 退货详情对象
	 * @param totalMoney  总金额
	 * @param reCause    退货原因
	 * @param jsonStr   json参数
	 * @return 字符串
	 */
	@RequestMapping("/save")
	@ResponseBody
	public String save(ReturnsDetailModel returnDetail,BigDecimal totalMoney,String reCause,String jsonStr,HttpSession session) {	
		
		//新建退货模型对象
		SalesReturnModel salesReturn = new SalesReturnModel();
		//定义参数   设置退货ID随机为UUID - 空	
		String reId = UUID.randomUUID().toString().replaceAll("-", "");
		//退货表给退货ID设值(退货ID),是否有效设值
		salesReturn.setReId(reId);
		//退货表给退货原因设值(退货原因)
		salesReturn.setReCause(reCause);
		//退货表给退货金额设值(总金额)
		salesReturn.setReMoney(totalMoney);
		//退货表给分公司ID设值(100)
		DrugManagerModel manager=(DrugManagerModel) session.getAttribute("manager");
		salesReturn.setFilId(manager.getFilId());
		//退货表给是否有效设值(否)
		salesReturn.setIsva("否");
		//调用退货Service的save方法(退货)
		salesReturnService.save(salesReturn);
	
		//新建一个Gson对象
		Gson gson = new Gson();
		//TypeToken内的泛型就是Json数据中的类型（退货详情模型）
		java.lang.reflect.Type listType=new TypeToken<ArrayList<ReturnsDetailModel>>(){}.getType();
		//集合(退货详情模型) gson 上面定义的参数
		ArrayList<ReturnsDetailModel> list = gson.fromJson(jsonStr, listType);
		//初始化参数
		int rows = 0;
		//使用foreach生成退货详情表
		for(ReturnsDetailModel re:list){
			//设置退货详情ID随机为UUID -空
			String rdId = UUID.randomUUID().toString().replaceAll("-", "");
			//定义参数  小计 = 强转double.型(退货详情的物品数量) * 强转double.型(退货详情传过来的 折扣后单价s)
			double xiaoJi = Double.valueOf(re.getRdNumber()) * Double.valueOf(re.getMxPrices());
			//退货表给退货详细ID设值(退货详细ID)
			re.setRdId(rdId);
			//退货表给退货ID设值(退货ID)
			re.setReId(reId);
			//退货表给退货总金额T设值(总金额)
			re.setRdTotal(totalMoney);
			//退货表给退货小计S设值(强转BigDecimal.(xiaoji))
			re.setRdSubtotal(BigDecimal.valueOf(xiaoJi));
			//参数 =调用退货详情Service的增加方法
			rows = returnsDetailService.save(re);
			
		}
		
		//定义row = 退货Service的修改是否有效方法(退货得到退货Id)
		int row = salesReturnService.updateIsva(salesReturn.getReId());
		//退货表 = 调用退货Service的根据ID查找的方法 退货ID
		SalesReturnModel salesReturns = salesReturnService.findById(reId);
		//财务表  调用财务Service的根据分店ID查找的方法 (退货表得到的分店ID)
		FinancialSheetsModel financialsheets = financialSheetsService.selectByFilId(salesReturn.getFilId());
		//定义个 BigDecimal参数     财务表得到 财务价格  subtract (退货表s的退货金额)
		BigDecimal num = financialsheets.getFsPrice().subtract(salesReturns.getReMoney());
		//财务表给财务价格赋值(上面相减的金额 ) 
		financialsheets.setFsPrice(num);
		//调用财务Service 修改方法(财务表);
		financialSheetsService.update(financialsheets);
		//新建一个财务记录对象
		FinancialRecordModel financialRecord = new FinancialRecordModel();
		//定义String参数   = 为UUID随机 -空
		String frId = UUID.randomUUID().toString().replaceAll("-", "");
		
		//财务记录表给财务记录ID设值(财务记录ID)
		financialRecord.setFrId(frId);
		//财务记录表给财务ID设值(财务表得到财务ID)
		financialRecord.setFsId(financialsheets.getFsId());
		//财务记录表给业务ID设值(退货ID)
		financialRecord.setPwId(reId);
		//财务记录表给总价格S设值(财务表得到财务价格)
		financialRecord.setFrSumprice(financialsheets.getFsPrice());
		//财务记录表给财务价格设值(退货得到退货金额)
		financialRecord.setFrPrice(salesReturn.getReMoney());
		//财务记录表给财务名称设值(支出)
		financialRecord.setFrName("支出");	
		//财务记录表给财务记录备注设值(退货表得到退货原因)
		financialRecord.setFrRemark(salesReturn.getReCause());
		//财务记录表给是否有效设值(否)
		financialRecord.setIsva("否");
		//取到当前时间给财务记录时间
		//新建时间对象(新日期得到时间)
		Timestamp frDate = new Timestamp(new Date().getTime());
		//财务记录给财务时间设值(上面的时间)
		financialRecord.setFrTime(frDate);
		//调用财务记录Service的增加方法(财务记录)
		financialRecordService.insertSelective(financialRecord);
	
		//退货详情集合  调用退货详情Service的根据退货ID查找(退货ID)
		List<ReturnsDetailModel> returnDetails = returnsDetailService.selectByReId(reId);
		
		//用foreach循环 退货详情
		for (ReturnsDetailModel returnsDetailModel : returnDetails) {
			//如果调用工具类不为空(退货详情的药品ID)
			if(!Tools.isEmpty(returnsDetailModel.getDrugId())){
				//库存模型=调用库存Service的根据分店ID查找方法(退货表得到分店ID，退货详情表的药品ID)
				RepertoryModel repertory = repertoryService.selectByFilId(salesReturn.getFilId(),returnsDetailModel.getDrugId());
				//如果库存不为空
				if(repertory != null){
					//定义Long参数    库存表得到库存数量+(退货详情的退货数量)
					Long nums = repertory.getRepNumber()+(returnsDetailModel.getRdNumber());
					//库存表给库存数量赋值(上面的值赋给它)
					repertory.setRepNumber(nums);
					//取到当前时间给财务记录时间
					//新建时间对象(新日期得到时间)
					Timestamp opTime = new Timestamp(new Date().getTime());
					//库存表给库存时间赋值(上面的值赋给它)
					repertory.setOptime(opTime);
					//调用库存Service的修改方法(库存)
					repertoryService.update(repertory);
					//TypeToken内的泛型就是Json数据中的类型(分店销售详情)
					java.lang.reflect.Type listTypes=new TypeToken<ArrayList<FdSellDetailModel>>(){}.getType();
					//集合(分店销售详情模型) gson 上面定义的参数
					ArrayList<FdSellDetailModel> lists = gson.fromJson(jsonStr, listTypes);
					
					//用foreach循环 分店销售详情表
					for (FdSellDetailModel fdSellDetailModel : lists) {
						//分店销售详情 = 调用分店销售详情Service的根据分店销售详情ID(mxId)查找的方法(分店销售详情得到分店销售详情ID)
						FdSellDetailModel fdSellDetail = fdSellDetailService.findByMxId(fdSellDetailModel.getMxId());
						//库存明细  =调用库存明细 Service的根据分店销售详情批号(MxNumber)查找的方法(强转String 分店销售详情表 得到  分店销售详情的批号)
						InventoryModel inventory = inventoryService.findByMxNumber(String.valueOf(fdSellDetail.getMxNumber()));
						//如果库存明细不为空
						if(inventory!=null){
							
							//foreach循环 退货详情表
							for (ReturnsDetailModel returnsDetailModels : returnDetails) {
								//库存明细表给库存数量赋值(库存明细表得到数量+ 退货详情得到退货数量.转为INT)
								inventory.setInvNumber(inventory.getInvNumber()+returnsDetailModels.getRdNumber().intValue());
								//取到当前时间
								//新建时间对象(新日期得到时间)
								Timestamp czTime = new Timestamp(new Date().getTime());
								//库存明细表给时间赋值(上面定义的时间参数)
								inventory.setCztime(czTime);
								//调用库存明细Service的修改Service方法(库存明细)
								inventoryService.updateByPrimaryKeySelective(inventory);
								//新建一个库存记录表对象
								InventoryRecordModel inventoryRecord = new InventoryRecordModel();
								//定义String 参数 = 设值库存记录ID为UUID  -空
								String irId = UUID.randomUUID().toString().replaceAll("-", "");
								//库存记录表给库存记录ID设值(库存记录ID)
								inventoryRecord.setIrId(irId);
								//库存记录表给业务ID设值(退货详情模型得到药品ID)
								inventoryRecord.setPwId(returnsDetailModels.getDrugId());
								//库存记录表给mat数量设值(退货详情模型得到退货数量.强转INT)
								inventoryRecord.setMatNum(returnsDetailModels.getRdNumber().intValue());
								//库存记录表给库存记录类型设值(入库)
								inventoryRecord.setIrType("入库");
								//库存记录表给库存记录时间设值(op时间)
								inventoryRecord.setIrTime(opTime);
								//库存记录表给分店ID设值(100)
								inventoryRecord.setFilId("100");
								//库存记录表给数量s设值(String强转(分店销售详情得到mx数量))
								inventoryRecord.setNumbers(String.valueOf(fdSellDetail.getMxNumber()));
								//调用库存记录Service的增加方法(库存记录)
								inventoryRecordService.insertSelective(inventoryRecord);
								//定义Long参数 =分店销售详情表中的数量Q - 退货详情表s的退货数量
								Long all = fdSellDetail.getMxQuantity()-returnsDetailModels.getRdNumber();
								//将上面的值赋给  分店销售详情模型的数量Q
								fdSellDetailModel.setMxQuantity(all);
								//调用分店销售详情Service的修改方法(分店销售详情模型)
								fdSellDetailService.updateByPrimaryKeySelective(fdSellDetailModel);
								
							}
						}	
					}
				}
				
			}
	
		}
		//如果rows大于零
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//返回失败
			return "no";
		}
		
	}
			
	/** 
	 * 财务减少 库存增加的方法(批发退货)    梅李娜
	 * @param returnDetail 退货详情对象
	 * @param totalMoney  总金额
	 * @param reCause    退货原因
	 * @param jsonStr   json参数
	 * @return 自定义参数
	 */
	@RequestMapping("/saves")
	@ResponseBody
	public String saves(ReturnsDetailModel returnDetail,BigDecimal totalMoney,String reCause,String jsonStr) {	
		
		//新建退货模型对象
		SalesReturnModel salesReturn = new SalesReturnModel();
		//定义String参数 =设置退货ID随机为UUID
		String reId = UUID.randomUUID().toString().replaceAll("-", "");
		//退货表给退货ID设值(退货ID) 
		salesReturn.setReId(reId);
		//退货表给退货原因设值(退货原因)
		salesReturn.setReCause(reCause);
		//退货表给退货金额设值(总金额)
		salesReturn.setReMoney(totalMoney);
		//退货表给分店ID设值(100)
		salesReturn.setFilId("100");
		//退货表给是否有效设值(否)
		salesReturn.setIsva("否");
		//调用退货Service的增加方法
		salesReturnService.save(salesReturn);
		
		//新建一个Gson对象
		Gson gson = new Gson();
		//TypeToken内的泛型就是Json数据中的类型(退货详情模型)
		java.lang.reflect.Type listType=new TypeToken<ArrayList<ReturnsDetailModel>>(){}.getType();
		//集合(退货详情模型) gson 上面定义的参数
		ArrayList<ReturnsDetailModel> list = gson.fromJson(jsonStr, listType);
		//初始化参数
		int rows = 0;
		//使用foreach生成退货详情表
		for(ReturnsDetailModel re:list){
			//定义String参数 =设置退货详情ID随机为UUID
			String rdId = UUID.randomUUID().toString().replaceAll("-", "");
			//退货详情表给退货详细ID设值(退货详细ID)
			re.setRdId(rdId);
			//退货详情表给退货ID设值（退货ID）
			re.setReId(reId);
			//退货详情表给退货总金额设值(总金额)
			re.setRdTotal(totalMoney);
			//退货详情表给退货数量设值(退货详情表得到退货数量)
			re.setRdNumber(re.getRdNumber());
			//定义行数=调用退货详情Service的增加方法
			rows = returnsDetailService.save(re);
			
		}
		//定义行数=调用退货Service的修改是否有效方法(退货得到退货ID)
		int row = salesReturnService.updateIsva(salesReturn.getReId());
		//退货表   调用退货Service的根据ID查找的方法 退货ID
		SalesReturnModel salesReturns = salesReturnService.findById(reId);
		//财务表  调用财务Service的根据分店ID查找的方法 (退货得到分店ID)
		FinancialSheetsModel financialsheets = financialSheetsService.selectByFilId(salesReturn.getFilId());
		//定义个 BigDecimal参数     用财务表的 财务价格  subtract 退货表s的退货金额
		BigDecimal num = financialsheets.getFsPrice().subtract(salesReturns.getReMoney());
		//财务表 给财务价格赋值(上面定义的参数)
		financialsheets.setFsPrice(num);
		//调用财务Service 修改方法(财务表);
		financialSheetsService.update(financialsheets);
		//新建一个财务记录对象
		FinancialRecordModel financialRecord = new FinancialRecordModel();
		//定义String 参数 =设置财务记录ID随机为UUID
		String frId = UUID.randomUUID().toString().replaceAll("-", "");
		//财务记录表给财务记录ID设值(财务记录ID)
		financialRecord.setFrId(frId);
		//财务记录表给财务ID设值(财务表得到财务ID)
		financialRecord.setFsId(financialsheets.getFsId());
		//财务记录表给业务ID设值(退货 ID)
		financialRecord.setPwId(reId);
		//财务记录表给财务记录总价格设值(财务表得到财务价格)
		financialRecord.setFrSumprice(financialsheets.getFsPrice());
		//财务记录表给财务价格设值(退货表得到退货金额),
		financialRecord.setFrPrice(salesReturn.getReMoney());
		//财务记录表给财务记录名称设值(支出)
		financialRecord.setFrName("支出");	
		//财务记录表给财务记录备注设值(退货得到退货原因)
		financialRecord.setFrRemark(salesReturn.getReCause());
		//财务记录表给是否有效设值(否)
		financialRecord.setIsva("否");
		//取到当前时间给财务记录时间
		//新建时间对象(新日期得到时间)
		Timestamp frDate = new Timestamp(new Date().getTime());
		//财务记录表给财务时间设值(上面的时间)
		financialRecord.setFrTime(frDate);
		//调用财务记录Service的增加方法(财务记录)
		financialRecordService.insertSelective(financialRecord);
		//退货详情模型集合  调用退货详情Service的根据退货ID查找(退货ID)
		List<ReturnsDetailModel> returnDetails = returnsDetailService.selectByReId(reId);
		//定义参数ooo为零
		int ooo = 0 ;
		//用foreach循环 退货详情
		for (ReturnsDetailModel returnsDetailModel : returnDetails) {
			//如果调用工具类不为空(退货详情模型得到药品ID)
			if(!Tools.isEmpty(returnsDetailModel.getDrugId())){
				//库存表  调用库存Service的选择通过分店ID查找(退货得到分店ID，退货详情模型得到药品ID)
				RepertoryModel repertory = repertoryService.selectByFilId(salesReturn.getFilId(),returnsDetailModel.getDrugId());
				//如果库存不为空
				if(repertory != null){
					//定义Long参数    库存表得到库存数量+ (退货详情表的退货数量)
					Long nums = repertory.getRepNumber()+(returnsDetailModel.getRdNumber());
					//库存表 给库存数量赋值(上面的参数)
					repertory.setRepNumber(nums);
					//取到当前时间赋值给操作时间
					//新建时间对象(新日期得到时间)
					Timestamp opTime = new Timestamp(new Date().getTime());
					//库存表给库存时间赋值(上面的当前时间)
					repertory.setOptime(opTime);
					//调用库存Service的修改方法(库存)
					repertoryService.update(repertory);
					//TypeToken内的泛型就是Json数据中的类型(批发详情模型)
					java.lang.reflect.Type listTypes=new TypeToken<ArrayList<WholesaleDetailModel>>(){}.getType();//TypeToken内的泛型就是Json数据中的类型
					//集合(批发详情模型) gson 上面定义的参数
					ArrayList<WholesaleDetailModel> lists = gson.fromJson(jsonStr, listTypes);
					//用foreach循环 批发详情表
					for (WholesaleDetailModel wholesaleDetailModel : lists) {
						//批发详情表  调用批发详情Service的根据批发详情ID查找的方法(批发详情模型得到批发详情ID)
						WholesaleDetailModel WholesaleDetail = wholesaleDetaiService.findByPfxqlId(wholesaleDetailModel.getPfxqlId());
						//定义参数ooo每次增加1
						ooo+=1;
						//库存明细表  调用库存明细 Service的根据分店销售详情批号(MxNumber)的方法(强转String. 批发详情表 得到批号)
						InventoryModel inventory = inventoryService.findByMxNumber(String.valueOf(WholesaleDetail.getNumbers()));
						//如果库存明细  不为空
						if(inventory!=null){
							//foreach循环 退货详情表
							for (ReturnsDetailModel returnsDetailModels : returnDetails) {
								//库存明细表给数量设值(库存明细表得到数量+ 退货详情模型s得到退货数量.强转int)
								inventory.setInvNumber(inventory.getInvNumber()+returnsDetailModels.getRdNumber().intValue());
								//新建时间对象(新日期得到时间)
								Timestamp czTime = new Timestamp(new Date().getTime());
								//库存明细 表给时间设值（上面的时间）
								inventory.setCztime(czTime);
								//调用库存明细Service的修改Service方法(库存明细)
								inventoryService.updateByPrimaryKeySelective(inventory);
								//新建一个库存记录表对象
								InventoryRecordModel inventoryRecord = new InventoryRecordModel();
								//定义一个String参数 = 设值库存记录ID为UUID
								String irId = UUID.randomUUID().toString();
								//库存记录表给库存记录ID赋值(库存记录ID)
								inventoryRecord.setIrId(irId);
								//库存记录表给业务ID设值(退货详情模型s得到药品ID)
								inventoryRecord.setPwId(returnsDetailModels.getDrugId());
								//库存记录表给mat数量设值(退货详情模型s得到退货数量.强转int)
								inventoryRecord.setMatNum(returnsDetailModels.getRdNumber().intValue());
								//库存记录表给库存类型设值(入库)
								inventoryRecord.setIrType("入库");
								//库存记录表给库存时间设值(op时间)
								inventoryRecord.setIrTime(opTime);
								//库存记录表给操作人设值()
								inventoryRecord.setOperator("小红");
								//库存记录表给是否有效设值
								inventoryRecord.setIsva("是");
								//库存记录表给分店ID设值
								inventoryRecord.setFilId("1");
								//库存记录表给数量s设值(String强转(批发详情得到数量s))
								inventoryRecord.setNumbers(String.valueOf(WholesaleDetail.getNumbers()));
								//调用库存记录Service的增加方法（库存记录）
								inventoryRecordService.insertSelective(inventoryRecord);
								
							}
						}
						//减少分店销售详情表中的数量
						//如果ooo除退货详情s的数量 模集合的数量等于 一
						if((ooo/returnDetails.size())%lists.size()==1){
							//定义int参数 = 批发详情得到批发详情数量 - 退货详情模型得到退货数量.强转int
							int all = WholesaleDetail.getPfxqNumber	()-returnsDetailModel.getRdNumber().intValue();
							//批发详情模型给批发详情数量赋值(上面定义的int参数)
							wholesaleDetailModel.setPfxqNumber(all);
							//调用批发详情Service的修改方法(批发详情模型)
							wholesaleDetaiService.updateByPrimaryKeySelective(wholesaleDetailModel);
						}
					}
				}	
			}	
	
		}
		//如果行数大于零
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//返回失败
			return "no";
		}
		
	}
	
	/** 
	 * 财务减少 库存增加的方法(分店退货)    梅李娜
	 * @param returnDetail 退货详情对象
	 * @param totalMoney  总金额
	 * @param reCause    退货原因
	 * @param jsonStr   json参数
	 * @return 自定义参数
	 */
	@RequestMapping("/savess")
	@ResponseBody
	public String savess(ReturnsDetailModel returnDetail,BigDecimal totalMoney,String reCause,String jsonStr) {	
		//新建退货模型对象
		SalesReturnModel salesReturn = new SalesReturnModel();
		//定义String参数 =设置退货ID随机为UUID
		String reId = UUID.randomUUID().toString().replaceAll("-", "");
		//退货表给退货ID赋值(退货ID)
		salesReturn.setReId(reId);
		//退货表给退货原因赋值(退货原因)
		salesReturn.setReCause(reCause);
		//退货表给退货金额赋值(总金额)
		salesReturn.setReMoney(totalMoney);
		//退货表给分店ID赋值(2)
		salesReturn.setFilId("2");
		//退货表给是否有效赋值(否)
		salesReturn.setIsva("否");
		//调用退货Service的保存方法(退货)
		salesReturnService.save(salesReturn);
		//新建一个Gson对象
		Gson gson = new Gson();
		//TypeToken内的泛型就是Json数据中的类型（退货详情模型）
		java.lang.reflect.Type listType=new TypeToken<ArrayList<ReturnsDetailModel>>(){}.getType();
		//集合(退货详情模型) gson 上面定义的参数
		ArrayList<ReturnsDetailModel> list = gson.fromJson(jsonStr, listType);
		//初始化参数
		int rows = 0;
		//使用foreach生成退货详情表
		for(ReturnsDetailModel re:list){
			//定义String参数 =设置退货详情ID随机为UUID
			String rdId = UUID.randomUUID().toString().replaceAll("-", "");
			//退货详情表给退货详细ID设值(退货详情ID)
			re.setRdId(rdId);
			//退货详情表给退货ID设值(退货ID)
			re.setReId(reId);
			//退货详情表给退货总金额设值(总金额)
			re.setRdTotal(totalMoney);
			//退货详情表给退货数量设值(退货详情表得到退货数量)
			re.setRdNumber(re.getRdNumber());
			//定义行数 =调用退货详情Service的保存方法
			rows = returnsDetailService.save(re);
			
		}
		//定义行数 = 调用 退货Service的修改是否有效方法（退货得到退货ID）
		int row = salesReturnService.updateIsva(salesReturn.getReId());
		//退货表  调用退货Service的根据ID查找的方法 退货ID
		SalesReturnModel salesReturns = salesReturnService.findById(reId);
		//财务表    调用财务Service的根据分店ID查找的方法 (退货得到分店ID)
		FinancialSheetsModel financialsheets = financialSheetsService.selectByFilId(salesReturn.getFilId());
		//定义个 BigDecimal参数     财务表得到财务价格  subtract 退货表得到退货金额
		BigDecimal num = financialsheets.getFsPrice().subtract(salesReturns.getReMoney());
		//财务表给财务价格赋值(上面定义的参数) 
		financialsheets.setFsPrice(num);
		//调用财务Service 修改方法(财务表);
		financialSheetsService.update(financialsheets);
		//新建一个 财务记录表
		FinancialRecordModel financialRecord = new FinancialRecordModel();
		//定义String参数  =设置财务记录ID随机为UUID
		String frId = UUID.randomUUID().toString().replaceAll("-", "");
		//财务记录表给财务记录ID赋值(财务记录ID)
		financialRecord.setFrId(frId);
		//财务记录表给财务ID赋值(财务表得到财务ID)
		financialRecord.setFsId(financialsheets.getFsId());
		//财务记录表给业务ID赋值(退货ID)
		financialRecord.setPwId(reId);
		//财务记录表给总金额S赋值(财务表得到财务价格)
		financialRecord.setFrSumprice(financialsheets.getFsPrice());
		//财务记录表给财务价格赋值(退货得到财务金额)
		financialRecord.setFrPrice(salesReturn.getReMoney());
		//财务记录表给财务名称赋值(支出)
		financialRecord.setFrName("支出");	
		//财务记录表给财务备注赋值(退货得到退货原因)
		financialRecord.setFrRemark(salesReturn.getReCause());
		//财务记录表给是否有效赋值(否)
		financialRecord.setIsva("否");
		//取到当前时间给财务记录时间
		//新建时间对象(新日期得到时间)
		Timestamp frDate = new Timestamp(new Date().getTime());
		//财务记录表给财务时间赋值(上面取到的时间)
		financialRecord.setFrTime(frDate);
		//调用财务记录Service的增加方法(财务记录)
		financialRecordService.insertSelective(financialRecord);
    	//退货详情集合  调用退货详情Service的根据退货ID查找(退货ID)
		List<ReturnsDetailModel> returnDetails = returnsDetailService.selectByReId(reId);	
		//用foreach循环 退货详情表
		for (ReturnsDetailModel returnsDetailModel : returnDetails) {
			//如果调用工具类的不为空(退货详情模型得到药品ID)
			if(!Tools.isEmpty(returnsDetailModel.getDrugId())){
				//库存表  = 调用库存Service的选择通过分店ID方法 (退货得到分店ID,退货详情模型得到药品ID)
				RepertoryModel repertory = repertoryService.selectByFilId(salesReturn.getFilId(),returnsDetailModel.getDrugId());
				//如果库存不为空
				if(repertory != null){
					//定义Long参数    库存表得到库存数量+ (退货详情模型得到退货数量)
					Long nums = repertory.getRepNumber()+(returnsDetailModel.getRdNumber());
					//库存表给库存数量赋值(上面的值赋给它)
					repertory.setRepNumber(nums);
					//取到当前时间赋值给操作时间
					//新建时间对象(新日期得到时间)
					Timestamp opTime = new Timestamp(new Date().getTime());
					//库存表给时间赋值(上面的值赋给它)
					repertory.setOptime(opTime);
					//调用库存Service的修改方法(库存)
					repertoryService.update(repertory);
					//TypeToken内的泛型就是Json数据中的类型（分店采购模型）
					java.lang.reflect.Type listTypes=new TypeToken<ArrayList<FdPurchaseModel>>(){}.getType();//TypeToken内的泛型就是Json数据中的类型
					//集合(分店采购模型) gson 上面定义的参数
					ArrayList<FdPurchaseModel> lists = gson.fromJson(jsonStr, listTypes);
					
					//用foreach循环 分店采购表
					for (FdPurchaseModel fdPurchaseModel : lists) {
						//分店采购表  调用分店采购Service的根据采购ID查找的方法(分店采购模型得到分店采购ID)
						FdPurchaseModel fdPurchase = fdPurchaseService.findByfdPoId(fdPurchaseModel.getFdPoId());
						//库存明细表  调用库存明细 Service的根据分店销售详情批号(MxNumber)的方法(强转String 分店采购表 得到  分店的批号)
						InventoryModel inventory = inventoryService.findByMxNumber(String.valueOf(fdPurchase.getFdNumber()));
						//如果库存明细不为空
						if(inventory!=null){
							//foreach循环 退货详情表
							for (ReturnsDetailModel returnsDetailModels : returnDetails) {
								//库存明细表给库存数量赋值(库存明细表得到库存数量+ 退货详情模型s得到退货数量.强转int)
								inventory.setInvNumber(inventory.getInvNumber()+returnsDetailModels.getRdNumber().intValue());
								//新建时间(新日期得到时间)
								Timestamp czTime = new Timestamp(new Date().getTime());
								//库存明细表给时间赋值(上面时间)
								inventory.setCztime(czTime);
								//调用库存明细Service的修改方法(库存明细)
								inventoryService.updateByPrimaryKeySelective(inventory);
								//新建一个库存记录表对象
								InventoryRecordModel inventoryRecord = new InventoryRecordModel();
								//定义String参数 =设置库存记录ID为UUID随机
								String irId = UUID.randomUUID().toString();
								//库存记录表给库存记录ID赋值(库存记录ID)
								inventoryRecord.setIrId(irId);
								//库存记录表给业务ID赋值(退货详情模型s得到药品ID)
								inventoryRecord.setPwId(returnsDetailModels.getDrugId());
								//库存记录表给mat数量赋值(退货详情模型s得到页面退货数量.强转INT)
								inventoryRecord.setMatNum(returnsDetailModels.getRdNumber().intValue());
								//库存记录表给库存记录类型赋值(入库)
								inventoryRecord.setIrType("入库");
								//库存记录表给库存记录时间赋值(op时间)
								inventoryRecord.setIrTime(opTime);
								//库存记录表给数量s赋值(分店采购得到分店数量)
								inventoryRecord.setNumbers(fdPurchase.getFdNumber());
								//调用库存记录Service的增加方法
								inventoryRecordService.insertSelective(inventoryRecord);	
								//减少分店销售详情表中的数量
								//定义Long 参数 =采购得到分店总数量S - 退货详情模型s得到退货数量 
								Long all = fdPurchase.getFdSunnum()-returnsDetailModels.getRdNumber();
								//分店采购模型给分店总数量S赋值(上面定义的long参数)
								fdPurchaseModel.setFdSunnum(all);
								//调用分店采购Service的修改方法（分店采购模型）
								fdPurchaseService.updateByPrimaryKeySelective(fdPurchaseModel);	
							}
						}	
					}
				}
				
			}
		}
		//如果行数大于零
		if(rows>0){
			//返回成功
			return "ok";
		}else{
			//返回失败
			return "no";
		}		
	}	
}
